﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection.Metadata;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp2
{
    public class EventBus : IEventBus
    {
        //这里使用字典来模拟事件的订阅和发布
        private readonly Dictionary<Type, List<Delegate>> _handlers = new();
        public void Publish(IntegrationEvent @event)
        {
            if (_handlers.TryGetValue(@event.GetType(), out var handlers))
            {
                foreach (var handler in handlers)
                {
                    var concreteHandler = handler.DynamicInvoke(@event) as Task;
                    if (concreteHandler != null)
                    {
                        concreteHandler.Wait();
                    }
                }
            }
        }

        //public void Subscribe<TEvent, THandler>() where TEvent : IntegrationEvent where THandler : IIntegrationEventHandler<TEvent>
        //{
        //    if (!_handlers.TryGetValue(typeof(TEvent), out var handlers))
        //    {
        //        handlers = new List<Delegate>();
        //        _handlers[typeof(TEvent)] = handlers;
        //    }

        //    var handler = Activator.CreateInstance<THandler>;
        //    //string assemblyName = typeof(THandler).Assembly.GetName().Name;
        //    //string typeName = typeof(THandler).Name;
        //    //var handler = Activator.CreateInstance(assemblyName, typeName);
        //    var methodInfo = typeof(THandler).GetMethod("Handle");
        //    if (methodInfo != null)
        //    {
        //        Console.WriteLine("Method found: " + methodInfo.Name);
        //        /*
        //        使用指定的第一个参数创建指定类型的委托，该委托表示指定的静态或实例方法。

        //        要创建的委托类型
        //        委托绑定到的对象，或null将方法视为静态（在Visual Basic中为Shared）。
        //        MethodInfo描述委托要表示的静态或实例方法
        //        */
        //        /*
        //        error：无法绑定到目标方法，因为其签名与委托类型的签名不兼容。 
        //        */
        //        //var handlerDelegate = Delegate.CreateDelegate(typeof(Action<THandler>), handler, methodInfo);
        //        //handlers.Add(handlerDelegate);

        //        Delegate handlerDelegate = Delegate.CreateDelegate(typeof(Action<TEvent>), handler, methodInfo);
        //        //handlerDelegate.DynamicInvoke(); // 对于无参数方法，或者传入参数数组作为 DynamicInvoke 的参数以调用有参数的方法。

        //        handlers.Add(handlerDelegate);
        //    }
        //}
        public void Subscribe<TEvent, THandler>() where TEvent : IntegrationEvent where THandler : IIntegrationEventHandler<TEvent>
        {
            var eventType = typeof(TEvent);
            if (!_handlers.ContainsKey(eventType))
            {
                _handlers[eventType] = new List<Delegate>();
            }
            _handlers[eventType].Add(CreateHandler<TEvent, THandler>());
        }

        private Delegate CreateHandler<T, TH>() where T : IntegrationEvent where TH : IIntegrationEventHandler<T>
        {
            var instance = Activator.CreateInstance<TH>(); // 创建事件处理器实例
            var methodInfo = typeof(TH).GetMethod("Handle"); // 获取Handle方法信息
            var func = Delegate.CreateDelegate(typeof(Action<T>), instance, methodInfo); // 创建委托
            return func;
        }


        public void Unsubscribe<TEvent, THandler>() where TEvent : IntegrationEvent where THandler : IIntegrationEventHandler<TEvent>
        {
            //简化处理，实际使用中可能需要更复杂的逻辑来取消订阅
            _handlers.Remove(typeof(TEvent));
        }

    }
}
